package com.gzc.just.play.last.war.sceneserver.effect;

import com.gzc.just.play.last.war.sceneserver.gameobject.unit.GameUnit;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 状态效果管理器 - 管理单位身上的所有状态效果
 *
 * 功能：
 * - 效果的应用和移除
 * - 效果的更新和过期检查
 * - 效果的堆叠和覆盖逻辑
 * - 状态查询
 *
 * 对应C++的 SSPassitiveEffectMgr
 *
 * @author AI编程助手
 * @version 1.0
 * @since 2025-11-22
 */
public class StatusEffectManager {
    
    private static final Logger log = LoggerFactory.getLogger(StatusEffectManager.class);
    
    private final GameUnit owner;
    private final List<StatusEffect> effects = new CopyOnWriteArrayList<>();
    private final Map<StatusType, StatusEffect> lastEffectMap = new HashMap<>();
    private int effectIdCounter = 0;
    
    /**
     * 创建状态效果管理器
     *
     * @param owner 效果的所有者
     */
    public StatusEffectManager(GameUnit owner) {
        this.owner = owner;
    }
    
    /**
     * 应用一个状态效果
     *
     * @param effect 要应用的效果
     */
    public void applyEffect(StatusEffect effect) {
        if (effect == null) {
            log.warn("试图应用空效果");
            return;
        }
        
        // 检查是否已有相同类型的效果
        StatusEffect existing = lastEffectMap.get(effect.getStatusType());
        
        if (existing != null && existing.isActive()) {
            // 根据效果类型决定是覆盖还是堆叠
            if (shouldStackEffect(effect.getStatusType())) {
                existing.stack();
                log.debug("堆叠效果: {}", effect.getStatusType().getDisplayName());
            } else {
                // 覆盖旧效果
                removeEffect(existing.getId());
                applyNewEffect(effect);
            }
        } else {
            applyNewEffect(effect);
        }
    }
    
    /**
     * 应用新效果
     */
    private void applyNewEffect(StatusEffect effect) {
        effects.add(effect);
        lastEffectMap.put(effect.getStatusType(), effect);
        effect.onApply();
        log.debug("应用新效果: {} (ID: {})", effect.getStatusType().getDisplayName(), effect.getId());
    }
    
    /**
     * 移除指定ID的效果
     *
     * @param effectId 效果ID
     */
    public void removeEffect(String effectId) {
        for (StatusEffect effect : effects) {
            if (effect.getId().equals(effectId)) {
                removeEffect(effect);
                return;
            }
        }
    }
    
    /**
     * 移除效果
     */
    public void removeEffect(StatusEffect effect) {
        if (effects.remove(effect)) {
            if (lastEffectMap.get(effect.getStatusType()) == effect) {
                lastEffectMap.remove(effect.getStatusType());
            }
            effect.onRemove();
            log.debug("移除效果: {}", effect.getStatusType().getDisplayName());
        }
    }
    
    /**
     * 移除指定类型的所有效果
     *
     * @param statusType 状态类型
     */
    public void removeEffectByType(StatusType statusType) {
        List<StatusEffect> toRemove = new ArrayList<>();
        for (StatusEffect effect : effects) {
            if (effect.getStatusType() == statusType) {
                toRemove.add(effect);
            }
        }
        
        for (StatusEffect effect : toRemove) {
            removeEffect(effect);
        }
    }
    
    /**
     * 刷新效果（重新应用同类型效果）
     *
     * @param statusType 状态类型
     */
    public void refreshEffect(StatusType statusType) {
        StatusEffect effect = lastEffectMap.get(statusType);
        if (effect != null) {
            effect.onRefresh();
            log.debug("刷新效果: {}", statusType.getDisplayName());
        }
    }
    
    /**
     * 更新所有效果
     *
     * @param currentTime 当前时间
     * @param deltaTime 时间间隔（毫秒）
     */
    public void updateEffects(long currentTime, long deltaTime) {
        List<StatusEffect> toRemove = new ArrayList<>();
        
        for (StatusEffect effect : effects) {
            if (effect.shouldRemove()) {
                toRemove.add(effect);
            } else {
                effect.onUpdate(currentTime, deltaTime);
            }
        }
        
        for (StatusEffect effect : toRemove) {
            removeEffect(effect);
        }
    }
    
    /**
     * 清除所有效果
     */
    public void clearAllEffects() {
        List<StatusEffect> toRemove = new ArrayList<>(effects);
        for (StatusEffect effect : toRemove) {
            removeEffect(effect);
        }
    }
    
    /**
     * 获取特定类型的效果
     *
     * @param statusType 状态类型
     * @return 效果，如果不存在返回null
     */
    public StatusEffect getEffect(StatusType statusType) {
        return lastEffectMap.get(statusType);
    }
    
    /**
     * 检查是否拥有指定的效果
     *
     * @param statusType 状态类型
     * @return 如果拥有此效果，返回true
     */
    public boolean hasEffect(StatusType statusType) {
        StatusEffect effect = lastEffectMap.get(statusType);
        return effect != null && effect.isActive();
    }
    
    /**
     * 获取所有活跃的效果
     */
    public List<StatusEffect> getActiveEffects() {
        List<StatusEffect> active = new ArrayList<>();
        for (StatusEffect effect : effects) {
            if (effect.isActive()) {
                active.add(effect);
            }
        }
        return active;
    }
    
    /**
     * 获取指定类型的所有效果
     */
    public List<StatusEffect> getEffectsByType(StatusType statusType) {
        List<StatusEffect> result = new ArrayList<>();
        for (StatusEffect effect : effects) {
            if (effect.getStatusType() == statusType) {
                result.add(effect);
            }
        }
        return result;
    }
    
    /**
     * 判断是否受到控制类状态影响
     *
     * @return 如果受到控制，返回true
     */
    public boolean isControlled() {
        for (StatusEffect effect : effects) {
            if (effect.getStatusType().isCrowdControl() && effect.isActive()) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 判断是否被沉默
     */
    public boolean isSilenced() {
        return hasEffect(StatusType.SILENCE);
    }
    
    /**
     * 判断是否被冻结
     */
    public boolean isFrozen() {
        return hasEffect(StatusType.FREEZE);
    }
    
    /**
     * 判断是否被眩晕
     */
    public boolean isStunned() {
        return hasEffect(StatusType.STUN);
    }
    
    /**
     * 判断是否无敌
     */
    public boolean isInvulnerable() {
        return hasEffect(StatusType.INVULNERABLE);
    }
    
    /**
     * 获取移动速度修正（基于减速效果）
     *
     * @return 速度倍数（1.0表示正常）
     */
    public double getSpeedModifier() {
        double modifier = 1.0;
        
        if (hasEffect(StatusType.FREEZE)) {
            return 0; // 冻结：无法移动
        }
        
        if (hasEffect(StatusType.SLOW)) {
            modifier *= 0.5; // 减速：50%
        }
        
        if (hasEffect(StatusType.HASTE)) {
            modifier *= 1.5; // 加速：150%
        }
        
        return Math.max(0, modifier);
    }
    
    /**
     * 获取伤害修正（基于增强/减弱效果）
     *
     * @return 伤害倍数（1.0表示正常）
     */
    public double getDamageModifier() {
        double modifier = 1.0;
        
        if (hasEffect(StatusType.POWER)) {
            modifier *= 1.5; // 力量：150%
        }
        
        if (hasEffect(StatusType.WEAKNESS)) {
            modifier *= 0.5; // 虚弱：50%
        }
        
        if (hasEffect(StatusType.CURSE)) {
            modifier *= 1.2; // 诅咒：受伤加重20%
        }
        
        return Math.max(0, modifier);
    }
    
    /**
     * 获取防御修正
     *
     * @return 防御倍数（1.0表示正常）
     */
    public double getDefenseModifier() {
        double modifier = 1.0;
        
        if (hasEffect(StatusType.SHIELD)) {
            modifier *= 1.5; // 护盾：150%
        }
        
        if (hasEffect(StatusType.FRAGILE)) {
            modifier *= 0.7; // 脆弱：70%
        }
        
        if (hasEffect(StatusType.VULNERABLE)) {
            modifier *= 0.6; // 易伤：60%
        }
        
        return Math.max(0, modifier);
    }
    
    /**
     * 判断是否应该堆叠效果
     */
    private boolean shouldStackEffect(StatusType statusType) {
        // 某些效果不堆叠，直接覆盖
        switch (statusType) {
            case STUN:
            case FREEZE:
            case SILENCE:
            case INVULNERABLE:
                return false;
            default:
                return true;
        }
    }
    
    /**
     * 生成效果ID
     */
    protected String generateEffectId() {
        return String.format("effect_%d_%d", owner.getObjectId(), effectIdCounter++);
    }
    
    /**
     * 获取效果数量
     */
    public int getEffectCount() {
        return effects.size();
    }
    
    /**
     * 获取效果统计信息
     */
    public String getEffectsSummary() {
        StringBuilder sb = new StringBuilder();
        sb.append("状态效果摘要:\n");
        
        for (StatusEffect effect : getActiveEffects()) {
            sb.append(String.format("  - %s (剩余: %dms, 堆叠: %d)\n",
                effect.getStatusType().getDisplayName(),
                effect.getRemainingDuration(),
                effect.getStackCount()));
        }
        
        if (effects.isEmpty()) {
            sb.append("  (无状态效果)");
        }
        
        return sb.toString();
    }
}
